Go (أو Golang) هي لغة برمجة حديثة طورتها Google في 2009، تتميز بالبساطة، الأداء العالي، والدعم المدمج للتزامن. هذه الدورة سترشدك عبر الأساسيات من التثبيت إلى بناء تطبيق عملي، مع أمثلة توضح كيفية الاستفادة من ميزات Go.
Go هي لغة بسيطة وسريعة تُستخدم في تطبيقات الخادومات، الأنظمة الموزعة، والتطبيقات السحابية.
go version في الطرفية للتأكد من التثبيت.package main ودالة main.
                            package main
                            import "fmt"
                            func main() {
                                fmt.Println("مرحبًا بك في Go!")
                            }
                            // ✅ مرحبًا بك في Go!
                        
                    Go تتطلب تحديد أنواع البيانات للمتغيرات، مع دعم الاستنتاج التلقائي.
                            package main
                            import "fmt"
                            func main() {
                                var name string = "علي"
                                age := 25
                                height := 1.75
                                isActive := true
                                fmt.Println(name, age, height, isActive)
                            }
                            // ✅ علي 25 1.75 true
                        
                    Go تدعم التحكم في التدفق باستخدام الجمل الشرطية.
                            package main
                            import "fmt"
                            func main() {
                                score := 85
                                if score >= 90 {
                                    fmt.Println("ممتاز")
                                } else if score >= 70 {
                                    fmt.Println("جيد")
                                } else {
                                    fmt.Println("حاول مرة أخرى")
                                }
                                // ✅ جيد
                            }
                        
                    Go تستخدم for كحلقة وحيدة للتكرار.
                            package main
                            import "fmt"
                            func main() {
                                for i := 0; i < 3; i++ {
                                    fmt.Println("تكرار:", i)
                                }
                                // ✅ تكرار: 0 تكرار: 1 تكرار: 2
                            }
                        
                    الدوال تُستخدم لتنظيم الكود وإعادة استخدامه، مع دعم إرجاع قيم متعددة.
func وتحديد نوع الإرجاع.
                            package main
                            import "fmt"
                            func add(a int, b int) int {
                                return a + b
                            }
                            func swap(x, y string) (string, string) {
                                return y, x
                            }
                            func main() {
                                sum := add(5, 3)
                                fmt.Println("المجموع:", sum)  // ✅ المجموع: 8
                                a, b := swap("علي", "أحمد")
                                fmt.Println(a, b)  // ✅ أحمد علي
                            }
                        
                    Go يوفر هياكل بيانات لتخزين مجموعات من العناصر.
[] وappend.
                            package main
                            import "fmt"
                            func main() {
                                var arr [3]int = [3]int{1, 2, 3}
                                slice := []string{"تفاح", "موز"}
                                slice = append(slice, "برتقال")
                                fmt.Println(arr[0])  // ✅ 1
                                fmt.Println(slice)   // ✅ [تفاح موز برتقال]
                            }
                        
                    الخرائط (Maps) تُستخدم لتخزين البيانات بصيغة مفتاح-قيمة.
map[نوع_المفتاح]نوع_القيمة.delete)، والوصول إلى القيم.
                            package main
                            import "fmt"
                            func main() {
                                person := map[string]string{
                                    "name": "علي",
                                    "city": "القاهرة",
                                }
                                person["age"] = "25"
                                delete(person, "city")
                                fmt.Println(person["name"])  // ✅ علي
                                fmt.Println(person)          // ✅ map[age:25 name:علي]
                            }
                        
                    Go يعتمد على إرجاع الأخطاء كقيم بدلاً من الاستثناءات.
                            package main
                            import (
                                "errors"
                                "fmt"
                            )
                            func divide(a, b int) (int, error) {
                                if b == 0 {
                                    return 0, errors.New("القسمة على صفر")
                                }
                                return a / b, nil
                            }
                            func main() {
                                result, err := divide(10, 0)
                                if err != nil {
                                    fmt.Println("خطأ:", err)
                                } else {
                                    fmt.Println("النتيجة:", result)
                                }
                                // ✅ خطأ: القسمة على صفر
                            }
                        
                    الهياكل تُستخدم لتجميع البيانات في كيان واحد.
struct..).
                            package main
                            import "fmt"
                            type Person struct {
                                Name string
                                Age  int
                            }
                            func main() {
                                p := Person{Name: "علي", Age: 25}
                                fmt.Println(p.Name)  // ✅ علي
                                p.Age = 26
                                fmt.Println(p)  // ✅ {علي 26}
                            }
                        
                    Go تتميز بدعم مدمج للتعامل مع العمليات المتزامنة باستخدام Goroutines وChannels.
go.
                            package main
                            import (
                                "fmt"
                                "time"
                            )
                            func sayHello() {
                                fmt.Println("مرحبًا من Goroutine!")
                            }
                            func main() {
                                go sayHello()
                                time.Sleep(time.Second)  // انتظر للسماح لـ Goroutine بالعمل
                                fmt.Println("انتهى البرنامج")
                            }
                            // ✅ مرحبًا من Goroutine! \n انتهى البرنامج
                        
                    مشروع يجمع المفاهيم الأساسية في تطبيق عملي.
                            package main
                            import "fmt"
                            type Task struct {
                                Title     string
                                Completed bool
                            }
                            func addTask(tasks []Task, title string) []Task {
                                return append(tasks, Task{Title: title, Completed: false})
                            }
                            func completeTask(tasks []Task, index int) []Task {
                                tasks[index].Completed = true
                                return tasks
                            }
                            func main() {
                                tasks := []Task{}
                                tasks = addTask(tasks, "كتابة كود")
                                tasks = addTask(tasks, "اختبار البرنامج")
                                tasks = completeTask(tasks, 0)
                                for i, task := range tasks {
                                    status := "غير مكتمل"
                                    if task.Completed {
                                        status = "مكتمل"
                                    }
                                    fmt.Printf("%d: %s - %s\n", i, task.Title, status)
                                }
                                // ✅ 0: كتابة كود - مكتمل
                                // ✅ 1: اختبار البرنامج - غير مكتمل
                            }